home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-13 / thesrc10.zip / COMM4.C < prev    next >
C/C++ Source or Header  |  1992-08-12  |  54KB  |  1,781 lines
  1. /***********************************************************************/
  2. /* COMM4.C - Commands P-S                                              */
  3. /* This file contains all commands that can be assigned to function    */
  4. /* keys or typed on the command line.                                  */
  5. /***********************************************************************/
  6. /*
  7.  * THE - The Hessling Editor. A text editor similar to VM/CMS xedit.
  8.  * Copyright (C) 1991,1992 Mark Hessling
  9.  *
  10.  * This program is free software; you can redistribute it and/or
  11.  * modify it under the terms of the GNU General Public License as
  12.  * published by the Free Software Foundation; either version 2 of
  13.  * the License, or any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18.  * General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to:
  22.  *
  23.  *    The Free Software Foundation, Inc.
  24.  *    675 Mass Ave,
  25.  *    Cambridge, MA 02139 USA.
  26.  *
  27.  *
  28.  * If you make modifications to this software that you feel increases
  29.  * it usefulness for the rest of the community, please email the
  30.  * changes, enhancements, bug fixes as well as any and all ideas to me.
  31.  * This software is going to be maintained and enhanced as deemed
  32.  * necessary by the community.
  33.  *
  34.  * Mark Hessling                     email: M.Hessling@itc.gu.edu.au
  35.  * 36 David Road                     Phone: +61 7 849 7731
  36.  * Holland Park                      Fax:   +61 7 875 7877
  37.  * QLD 4121
  38.  * Australia
  39.  */
  40. #include <stdio.h>
  41. #include <stdlib.h>
  42.  
  43. #include "the.h"
  44.  
  45. /*#define DEBUG 1*/
  46.  
  47. /*-------------------------- external data ----------------------------*/
  48. extern LINE *next_line,*curr_line;
  49. extern VIEW_DETAILS *vd_current,*vd_first,*vd_mark;
  50. extern char current_screen;
  51. extern SCREEN_DETAILS screen[MAX_SCREENS];        /* screen structures */
  52. extern char display_screens;                      /* number of screens */
  53. extern char number_of_views;                   /* number of open files */
  54. extern bool horizontal;
  55. extern char current_file;         /* pointer to current file */
  56. extern WINDOW *foot,*error_window,*divider;
  57. extern char error_on_screen;
  58. extern unsigned char *rec;
  59. extern unsigned short rec_len;
  60. extern unsigned char *cmd_rec;
  61. extern unsigned short cmd_rec_len;
  62. extern unsigned char mode_insert;        /* defines insert mode toggle */
  63. extern unsigned char in_profile;    /* indicates if processing profile */
  64. extern unsigned char *tempfilename;
  65. extern unsigned short file_start;
  66.  
  67. extern unsigned char temp_cmd[150];
  68. extern unsigned char dir_filename[80];
  69. extern unsigned char dir_pathname[80];
  70. extern unsigned char sp_path[MAX_FILE_NAME+1] ;
  71. extern unsigned char sp_fname[MAX_FILE_NAME+1] ;
  72. extern unsigned char dir_path[MAX_FILE_NAME+1] ;    /* for dir and ls commands */
  73. extern bool clear_command;
  74. extern short save_coord_x[VIEW_WINDOWS];
  75. extern short save_coord_y[VIEW_WINDOWS];
  76. /*---------------------- function definitions -------------------------*/
  77. #ifdef PROTO
  78. void split_command(unsigned char *,unsigned char *,unsigned char *);
  79. int param_split(unsigned char *,unsigned char *[],int );
  80. long valid_target(unsigned char *);
  81. int get_row_for_focus_line(int,long,long);
  82. unsigned char *get_key_definition(unsigned short key);
  83. void print_line(char,long,short,unsigned char *,unsigned char *);
  84. bool valid_set_command(char *);
  85. unsigned char *get_command(char);
  86. #else
  87. void split_command();
  88. int param_split();
  89. long valid_target();
  90. int get_row_for_focus_line();
  91. unsigned char *get_key_definition();
  92. void print_line();
  93. bool valid_set_command();
  94. unsigned char *get_command();
  95. #endif
  96. /*man-start*********************************************************************
  97. COMMAND
  98.      prefix - set prefix area attributes
  99.  
  100. SYNTAX
  101.      PREfix ON|OFF [Left|Right]
  102.  
  103. DESCRIPTION
  104.      The PREFIX set command determines if the prefix area is displayed
  105.      and if so, where it is displayed.
  106.      Executed from within the profile, the only effect is that the
  107.      defaults for all files is changed.
  108.      Executed from the command line, the PREFIX command changes the
  109.      current window displays to reflect the required options.
  110.  
  111. COMPATIBILITY
  112.      Does not support PREFIX NULLS or PREFIX SYNONYM.
  113.  
  114. DEFAULT
  115.      PREFIX ON LEFT
  116.  
  117. STATUS
  118.      Complete
  119. **man-end**********************************************************************/
  120. #ifdef PROTO
  121. int Prefix(unsigned char *params)
  122. #else
  123. int Prefix(params)
  124. unsigned char *params;
  125. #endif
  126. /***********************************************************************/
  127. {
  128. /*--------------------------- extern data -----------------------------*/
  129. extern unsigned char PRE_ONx;
  130. extern unsigned char PRE_LEFTx;
  131. /*--------------------------- local data ------------------------------*/
  132. #define PRE_PARAMS  2
  133.  unsigned char *word[PRE_PARAMS+1];
  134.  char parm[PRE_PARAMS];
  135.  register int i;
  136.  unsigned short num_params;
  137.  unsigned short x,y;
  138.  char pre_col;
  139.  short rc;
  140. /*--------------------------- processing ------------------------------*/
  141. #ifdef TRACE
  142.  trace_function("comm4.c:   Prefix");
  143. #endif
  144.  num_params = param_split(params,word,PRE_PARAMS);
  145.  for (i=0;i<PRE_PARAMS;i++)
  146.      parm[i] = UNDEFINED_OPERAND;
  147.  if (equal("on",word[0],2))
  148.     parm[0] = TRUE;
  149.  if (equal("off",word[0],3))
  150.     parm[0] = FALSE;
  151.  if (parm[0] == UNDEFINED_OPERAND)
  152.    {
  153.     display_error(1,word[0]);
  154. #ifdef TRACE
  155.     trace_return();
  156. #endif
  157.     return(OK);
  158.    }
  159.  switch(parm[0])
  160.     {
  161.      case TRUE:                                           /* prefix on */
  162.          if (equal("left",word[1],1))
  163.             parm[1] = TRUE;
  164.          if (equal("right",word[1],1))
  165.             parm[1] = FALSE;
  166.          if (parm[1] == UNDEFINED_OPERAND)
  167.            {
  168.             display_error(1,word[1]);
  169. #ifdef TRACE
  170.             trace_return();
  171. #endif
  172.             return(OK);
  173.            }
  174.          break;
  175.      case FALSE:
  176.          if (strcmp(word[1],"") != 0)
  177.            {
  178.             display_error(1,word[1]);
  179. #ifdef TRACE
  180.             trace_return();
  181. #endif
  182.             return(OK);
  183.            }
  184.          break;
  185.     }
  186.  PRE_ONx = parm[0];
  187.  PRE_LEFTx = parm[1];
  188.  if (in_profile)
  189.    {
  190. #ifdef TRACE
  191.     trace_return();
  192. #endif
  193.     return(OK);
  194.    }
  195.  
  196. /*---------------------------------------------------------------------*/
  197. /* Now for the real work. Depending on the current state of the prefix */
  198. /* and the intentions of the user, turn on or off the prefix area and  */
  199. /* rearrange the MAIN window.                                          */
  200. /*---------------------------------------------------------------------*/
  201.  switch(CURRENT_VIEW->prefix_on)
  202.    {
  203.     case TRUE:                               /* prefix is currently on */
  204.          switch(parm[0])
  205.            {
  206.             case TRUE:
  207. /*---------------------------------------------------------------------*/
  208. /* If the prefix is already on and in the same place as requested,     */
  209. /* ignore the command.                                                 */
  210. /*---------------------------------------------------------------------*/
  211.                  if (CURRENT_VIEW->prefix_left == parm[1])
  212.                     break;
  213. /*---------------------------------------------------------------------*/
  214. /* Now we have to swap the position of the MAIN and PREFIX windows.    */
  215. /* The simplest way is to move the windows to their new positions.     */
  216. /*---------------------------------------------------------------------*/
  217.                  if (CURRENT_VIEW->prefix_left)        /* prefix - left */
  218.                    {
  219.                     CURRENT_SCREEN.top_col -= PREFIX_WIDTH;
  220.                     pre_col = CURRENT_SCREEN.origin_x+CURRENT_SCREEN.screen_cols-PREFIX_WIDTH;
  221.                    }
  222.                  else
  223.                    {
  224.                     CURRENT_SCREEN.top_col += PREFIX_WIDTH;
  225.                     pre_col = CURRENT_SCREEN.origin_x;
  226.                    }
  227.                  rc = mvwin(CURRENT_WINDOW_MAIN,CURRENT_SCREEN.top_row,
  228.                                            CURRENT_SCREEN.top_col);
  229.                  rc = mvwin(CURRENT_WINDOW_PREFIX,CURRENT_SCREEN.top_row,
  230.                                            pre_col);
  231.                  CURRENT_VIEW->prefix_left = parm[1];
  232.                  break;
  233.             case FALSE:                     /* prefix to be turned off */
  234.                  delwin(CURRENT_WINDOW_PREFIX);
  235.                  getyx(CURRENT_WINDOW_MAIN,y,x);
  236.                  delwin(CURRENT_WINDOW_MAIN);
  237.                  CURRENT_SCREEN.cols += PREFIX_WIDTH;
  238.                  CURRENT_SCREEN.top_col = CURRENT_SCREEN.origin_x;
  239.                  CURRENT_VIEW->prefix_on = FALSE;
  240.                  CURRENT_WINDOW_MAIN = newwin(CURRENT_SCREEN.rows,
  241.                                               CURRENT_SCREEN.cols,
  242.                                               CURRENT_SCREEN.top_row,
  243.                                               CURRENT_SCREEN.top_col);
  244.                  wattrset(CURRENT_WINDOW_MAIN,colour[ATTR_FILEAREA]);
  245. #if !defined(SUN) && !defined(VMS)
  246.                  keypad(CURRENT_WINDOW_MAIN,TRUE);
  247. #endif
  248.                  if (CURRENT_VIEW->current_window == WINDOW_COMMAND)
  249.                     CURRENT_VIEW->previous_window = WINDOW_MAIN;
  250.                  else
  251.                    {
  252.                     CURRENT_VIEW->current_window = WINDOW_MAIN;
  253.                     CURRENT_VIEW->previous_window = WINDOW_COMMAND;
  254.                    }
  255.                  show_page();
  256.                  wmove(CURRENT_WINDOW_MAIN,y,x);
  257.                  break;
  258.            }
  259.          break;
  260.     case FALSE:                             /* prefix is currently off */
  261.          switch(parm[0])
  262.            {
  263.             case TRUE:
  264. /*---------------------------------------------------------------------*/
  265. /* Determine where the prefix is to go.                                */
  266. /*---------------------------------------------------------------------*/
  267.                  if (parm[1])                  /* prefix to go on left */
  268.                    {
  269.                     pre_col = CURRENT_SCREEN.origin_x;
  270.                     CURRENT_SCREEN.top_col = CURRENT_SCREEN.origin_x+PREFIX_WIDTH;
  271.                    }
  272.                  else
  273.                     pre_col = CURRENT_SCREEN.origin_x+CURRENT_SCREEN.screen_cols-PREFIX_WIDTH;
  274.                  CURRENT_SCREEN.cols -= PREFIX_WIDTH;
  275. /*---------------------------------------------------------------------*/
  276. /* Get position of cursor in MAIN window. Delete the existing MAIN     */
  277. /* window and recreate it with a reduced size. Also create the PREFIX  */
  278. /* window at the correct location.                                     */
  279. /*---------------------------------------------------------------------*/
  280.                  getyx(CURRENT_WINDOW_MAIN,y,x);
  281.                  delwin(CURRENT_WINDOW_MAIN);
  282.                  CURRENT_VIEW->prefix_on = TRUE;
  283.                  CURRENT_VIEW->prefix_left = parm[1];
  284.                  CURRENT_WINDOW_MAIN = newwin(CURRENT_SCREEN.rows,
  285.                                               CURRENT_SCREEN.cols,
  286.                                               CURRENT_SCREEN.top_row,
  287.                                               CURRENT_SCREEN.top_col);
  288.                  wattrset(CURRENT_WINDOW_MAIN,colour[ATTR_FILEAREA]);
  289. #if !defined(SUN) && !defined(VMS)
  290.                  keypad(CURRENT_WINDOW_MAIN,TRUE);
  291. #endif
  292.                  CURRENT_WINDOW_PREFIX = newwin(CURRENT_SCREEN.rows,PREFIX_WIDTH,
  293.                                          CURRENT_SCREEN.top_row,pre_col);
  294.                  wattrset(CURRENT_WINDOW_PREFIX,colour[ATTR_PREFIX]);
  295. #if !defined(SUN) && !defined(VMS)
  296.                  keypad(CURRENT_WINDOW_PREFIX,TRUE);
  297. #endif
  298.                  show_page();
  299. /*---------------------------------------------------------------------*/
  300. /* If the previous column position is now no longer valid, set the     */
  301. /* column position to 0.                                               */
  302. /*---------------------------------------------------------------------*/
  303.                  if (x > CURRENT_SCREEN.cols)
  304.                     x = 0;
  305.                  wmove(CURRENT_WINDOW_MAIN,y,x);
  306.                  break;
  307.             case FALSE:
  308. /*---------------------------------------------------------------------*/
  309. /* If the prefix is already off, ignore request to turn it off.        */
  310. /*---------------------------------------------------------------------*/
  311.                  break;
  312.            }
  313.          break;
  314.    }
  315. #ifdef TRACE
  316.  trace_return();
  317. #endif
  318.  return(OK);
  319. }
  320. /*man-start*********************************************************************
  321. COMMAND
  322.      print - send text to default printer or print spooler
  323.  
  324. SYNTAX
  325.      PRint [target] [n]
  326.      PRint LINE [text]
  327.      PRint STRING [text]
  328.      PRint FORMfeed
  329.      PRint CLOSE
  330.  
  331. DESCRIPTION
  332.      The PRINT command writes a portion of the current file to the default
  333.      printer or print spooler, or text entered on the command line.
  334.      PRINT LINE sends the remainder of the text on the command line to
  335.      the printer followed by a CR/LF (DOS) or LF(UNIX).
  336.      PRINT STRING sends the remainder of the text on the command line to
  337.      the printer without any trailing line terminator.
  338.      PRINT FORMFEED sends a formfeed (^L) character to the printer.
  339.      PRINT CLOSE closes the printer spooler.
  340.      PRINT target sends text from the file contents up to the target to
  341.      the printer followed by a CR/LF (DOS) or LF(UNIX) after each line.
  342.      When an optional [n] isspecified, this sends a formfeed after [n]
  343.      successive lines of text.
  344.  
  345. COMPATIBILITY
  346.      Does not allow for different printer ports or print spoolers...yet.
  347.  
  348. SEE ALSO
  349.      printer
  350.  
  351. STATUS
  352.      Incomplete
  353. **man-end**********************************************************************/
  354. #ifdef PROTO
  355. int Print(unsigned char *params)
  356. #else
  357. int Print(params)
  358. unsigned char *params;
  359. #endif
  360. /***********************************************************************/
  361. {
  362. /*--------------------------- local data ------------------------------*/
  363. #define PRT_PARAMS  2
  364.  unsigned char *word[PRT_PARAMS+1];
  365.  unsigned short num_params;
  366.  long num_lines;
  367. /*--------------------------- processing ------------------------------*/
  368. #ifdef TRACE
  369.  trace_function("comm4.c:   Print");
  370. #endif
  371.  num_params = param_split(params,word,PRT_PARAMS);
  372.  if (num_params == 0)
  373.    {
  374.     num_params = 1;
  375.     word[0] = (unsigned char *)"1";
  376.    }
  377.  post_process_line(CURRENT_VIEW->focus_line);
  378.  if (equal("line",word[0],4))
  379.     print_line(NO,0L,0,(unsigned char *)word[1],
  380. #if defined(DOS) || defined(OS2)
  381.               (unsigned char *)"\r\n");
  382. #else
  383.               (unsigned char *)"\r");
  384. #endif
  385.  else
  386.     if (equal("string",word[0],5))
  387.        print_line(NO,0L,0,(unsigned char *)word[1],(unsigned char *)"");
  388.     else
  389.        if (equal("formfeed",word[0],4))
  390.          {
  391.           if (num_params > 1)
  392.             {
  393.              display_error(1,word[1]);
  394. #ifdef TRACE
  395.              trace_return();
  396. #endif
  397.              return(ERROR);
  398.             }
  399.           print_line(NO,0L,0,(unsigned char *)"",(unsigned char *)"\f");
  400.          }
  401.        else
  402.           if (equal("close",word[0],5))
  403.             {
  404.              if (num_params > 1)
  405.                {
  406.                 display_error(1,word[1]);
  407. #ifdef TRACE
  408.                 trace_return();
  409. #endif
  410.                 return(ERROR);
  411.                }
  412.              print_line(YES,0L,0,(unsigned char *)"",(unsigned char *)"");
  413.             }
  414.           else
  415.             {
  416.              if ((num_lines = valid_target(word[0])) == TARGET_ERROR)
  417.                {
  418.                 display_error(4,word[0]);
  419. #ifdef TRACE
  420.                 trace_return();
  421. #endif
  422.                 return(ERROR);
  423.                }
  424.              if (num_params < 2)
  425.                 word[1] = (unsigned char *)"0";
  426.              if (valid_positive_integer(word[1]) == NO)
  427.                {
  428.                 display_error(4,word[0]);
  429. #ifdef TRACE
  430.                 trace_return();
  431. #endif
  432.                 return(ERROR);
  433.                }
  434.              print_line(NO,num_lines,atoi(word[1]),(unsigned char *)"",
  435.                         (unsigned char *)"");
  436.             }
  437. #ifdef TRACE
  438.  trace_return();
  439. #endif
  440.  return(OK);
  441. }
  442. /*man-start*********************************************************************
  443. COMMAND
  444.      printer - define printer spooler name
  445.  
  446. SYNTAX
  447.      PRINTER spooler
  448.  
  449. DESCRIPTION
  450.      The PRINTER command sets up the print spooler name to determine
  451.      where output from the PRINT command goes.
  452.  
  453. COMPATIBILITY
  454.      Compatible.
  455.  
  456. SEE ALSO
  457.      print
  458.  
  459. STATUS
  460.      Incomplete
  461. **man-end**********************************************************************/
  462. #ifdef PROTO
  463. int Printer(unsigned char *params)
  464. #else
  465. int Printer(params)
  466. unsigned char *params;
  467. #endif
  468. /***********************************************************************/
  469. {
  470. /*------------------------- external date -----------------------------*/
  471. #ifdef UNIX
  472.  extern unsigned char *spooler_name;
  473. /*--------------------------- processing ------------------------------*/
  474. #ifdef TRACE
  475.  trace_function("comm4.c:   Printer");
  476. #endif
  477.  if ((spooler_name = (unsigned char *)memRealloc(spooler_name,
  478.                                                  strlen(params)+1,
  479.                                                  "realloc spooler_name"))
  480.                                             == NULL)
  481.    {
  482.     display_error(30,"");
  483. #ifdef TRACE
  484.     trace_return();
  485. #endif
  486.     return(ERROR);
  487.    }
  488.  strcpy(spooler_name,params);
  489. #endif
  490. #ifdef TRACE
  491.  trace_return();
  492. #endif
  493.  return(OK);
  494. }
  495. /*man-start*********************************************************************
  496. COMMAND
  497.      put - write part of a file to another
  498.  
  499. SYNTAX
  500.      PUT [target] [fileid]
  501.  
  502. DESCRIPTION
  503.      The PUT command writes a portion of the current file to another
  504.      file, either explicit or temporary.
  505.      When no fileid is supplied the temporary file is overwritten.
  506.      When a fileid is supplied the portion of the file written out
  507.      is appended to the specified file.
  508.  
  509. COMPATIBILITY
  510.      Complete.
  511.  
  512. SEE ALSO
  513.      put,get
  514.  
  515. STATUS
  516.      Complete
  517. **man-end**********************************************************************/
  518. #ifdef PROTO
  519. int Put(unsigned char *params)
  520. #else
  521. int Put(params)
  522. unsigned char *params;
  523. #endif
  524. /***********************************************************************/
  525. {
  526. /*--------------------------- local data ------------------------------*/
  527. #define PUT_PARAMS  2
  528.  unsigned char *word[PUT_PARAMS+1];
  529.  unsigned short num_params;
  530.  long num_lines;
  531.  char append;
  532.  unsigned char *filename;
  533. /*--------------------------- processing ------------------------------*/
  534. #ifdef TRACE
  535.  trace_function("comm4.c:   Put");
  536. #endif
  537.  num_params = param_split(params,word,PUT_PARAMS);
  538.  if (num_params == 0)
  539.    {
  540.     num_params = 1;
  541.     word[0] = (unsigned char *)"1";
  542.    }
  543.  if (num_params > 2)
  544.    {
  545.     display_error(1,word[2]);
  546. #ifdef TRACE
  547.     trace_return();
  548. #endif
  549.     return(ERROR);
  550.    }
  551.  if ((num_lines = valid_target(word[0])) == TARGET_ERROR)
  552.    {
  553.     display_error(4,word[0]);
  554. #ifdef TRACE
  555.     trace_return();
  556. #endif
  557.     return(ERROR);
  558.    }
  559.  if (strcmp(word[1],"") == 0)   /* no fileid supplied */
  560.    {
  561.     append = NO;
  562.     filename = tempfilename;
  563.    }
  564.  else
  565.    {
  566.     append = YES;
  567.     filename = word[1];
  568.    }
  569.  
  570.  post_process_line(CURRENT_VIEW->focus_line);
  571.  if (save_file(filename,YES,num_lines,append) == ERROR)
  572.    {
  573. #ifdef TRACE
  574.     trace_return();
  575. #endif
  576.     return(ERROR);
  577.    }
  578.  
  579. #ifdef TRACE
  580.  trace_return();
  581. #endif
  582.  return(OK);
  583. }
  584. /*man-start*********************************************************************
  585. COMMAND
  586.      putd - write part of a file to another and delete
  587.  
  588. SYNTAX
  589.      PUTD [target] [fileid]
  590.  
  591. DESCRIPTION
  592.      The PUTD command writes a portion of the current file to another
  593.      file, either explicit or temporary and deletes those lines written.
  594.      When no fileid is supplied the temporary file is overwritten.
  595.      When a fileid is supplied the portion of the file written out
  596.      is appended to the specified file.
  597.  
  598. COMPATIBILITY
  599.      Complete.
  600.  
  601. SEE ALSO
  602.      put,get
  603.  
  604. STATUS
  605.      Complete
  606. **man-end**********************************************************************/
  607. #ifdef PROTO
  608. int Putd(unsigned char *params)
  609. #else
  610. int Putd(params)
  611. unsigned char *params;
  612. #endif
  613. /***********************************************************************/
  614. {
  615. /*--------------------------- local data ------------------------------*/
  616. #define PUTD_PARAMS  2
  617.  unsigned char *word[PUTD_PARAMS+1];
  618.  unsigned short num_params;
  619.  long num_lines;
  620.  char append;
  621.  unsigned char *filename;
  622.  extern unsigned char *tempfilename;
  623. /*--------------------------- processing ------------------------------*/
  624. #ifdef TRACE
  625.  trace_function("comm4.c:   Putd");
  626. #endif
  627.  num_params = param_split(params,word,PUTD_PARAMS);
  628.  if (num_params == 0)
  629.    {
  630.     num_params = 1;
  631.     word[0] = (unsigned char *)"1";
  632.    }
  633.  if (num_params > 2)
  634.    {
  635.     display_error(1,word[2]);
  636. #ifdef TRACE
  637.     trace_return();
  638. #endif
  639.     return(ERROR);
  640.    }
  641.  if ((num_lines = valid_target(word[0])) == TARGET_ERROR)
  642.    {
  643.     display_error(4,word[0]);
  644. #ifdef TRACE
  645.     trace_return();
  646. #endif
  647.     return(ERROR);
  648.    }
  649.  if (strcmp(word[1],"") == 0)   /* no fileid supplied */
  650.    {
  651.     append = NO;
  652.     filename = tempfilename;
  653.    }
  654.  else
  655.    {
  656.     append = YES;
  657.     filename = word[1];
  658.    }
  659.  
  660.  post_process_line(CURRENT_VIEW->focus_line);
  661.  if (save_file(filename,YES,num_lines,append) == ERROR)
  662.    {
  663. #ifdef TRACE
  664.     trace_return();
  665. #endif
  666.     return(ERROR);
  667.    }
  668.  
  669.  Delete_line(word[0]);
  670.  
  671. #ifdef TRACE
  672.  trace_return();
  673. #endif
  674.  return(OK);
  675. }
  676. /*man-start*********************************************************************
  677. COMMAND
  678.      quit - exit from the current file
  679.  
  680. SYNTAX
  681.      QUIT
  682.  
  683. DESCRIPTION
  684.      The QUIT command exits the user from the current file, provided
  685.      no changes have been made to the file. An error message will be
  686.      displayed if changes have been made.
  687.      The previous file in the ring then becomes the current file.
  688.      If the current file is the only file in the ring, the user is
  689.      returned to the Operating System.
  690.  
  691. COMPATIBILITY
  692.      Complete.
  693.  
  694. SEE ALSO
  695.      qquit
  696.  
  697. STATUS
  698.      Complete
  699. **man-end**********************************************************************/
  700. #ifdef PROTO
  701. int Quit(unsigned char *params)
  702. #else
  703. int Quit(params)
  704. unsigned char *params;
  705. #endif
  706. /***********************************************************************/
  707. {
  708. /*--------------------------- local data ------------------------------*/
  709. /*--------------------------- processing ------------------------------*/
  710. #ifdef TRACE
  711.  trace_function("comm4.c:   Quit");
  712. #endif
  713.  post_process_line(CURRENT_VIEW->focus_line);
  714.  if (CURRENT_FILE->save_alt > 0)
  715.    {
  716.     display_error(22,"");
  717. #ifdef TRACE
  718.     trace_return();
  719. #endif
  720.     return(OK);
  721.    }
  722.  free_view_memory();
  723. #ifdef TRACE
  724.  trace_return();
  725. #endif
  726.  return(QUIT);
  727. }
  728. /*man-start*********************************************************************
  729. COMMAND
  730.      qquit - exit from the current file
  731.  
  732. SYNTAX
  733.      QQuit
  734.  
  735. DESCRIPTION
  736.      The QQUIT command exits the user from the current file, whether
  737.      changes have been made to the file or not.
  738.      The previous file in the ring then becomes the current file.
  739.      If the current file is the only file in the ring, the user is
  740.      returned to the Operating System.
  741.  
  742. COMPATIBILITY
  743.      Complete.
  744.  
  745. SEE ALSO
  746.      quit
  747.  
  748. STATUS
  749.      Complete
  750. **man-end**********************************************************************/
  751. #ifdef PROTO
  752. int Qquit(unsigned char *params)
  753. #else
  754. int Qquit(params)
  755. unsigned char *params;
  756. #endif
  757. /***********************************************************************/
  758. {
  759. /*--------------------------- local data ------------------------------*/
  760. /*--------------------------- processing ------------------------------*/
  761. #ifdef TRACE
  762.  trace_function("comm4.c:   Qquit");
  763. #endif
  764.  post_process_line(CURRENT_VIEW->focus_line);
  765.  free_view_memory();
  766. #ifdef TRACE
  767.  trace_return();
  768. #endif
  769.  return(QUIT);
  770. }
  771. /*man-start*********************************************************************
  772. COMMAND
  773.      query - display various option settings
  774.  
  775. SYNTAX
  776.      Query RING|etc
  777.  
  778. DESCRIPTION
  779.      The QUERY command displays the various settings for options set
  780.      by THE.
  781.  
  782. COMPATIBILITY
  783.      Shows some options.
  784.  
  785. STATUS
  786.      Not started.
  787. **man-end**********************************************************************/
  788. #ifdef PROTO
  789. int Query(unsigned char *params)
  790. #else
  791. int Query(params)
  792. unsigned char *params;
  793. #endif
  794. /***********************************************************************/
  795. {
  796. /*--------------------------- local data ------------------------------*/
  797. /*--------------------------- processing ------------------------------*/
  798. #ifdef TRACE
  799.  trace_function("comm4.c:   Query");
  800. #endif
  801. #ifdef TRACE
  802.  trace_return();
  803. #endif
  804.  return(OK);
  805. }
  806. /*man-start*********************************************************************
  807. COMMAND
  808.      recover - recover changed or deleted lines
  809.  
  810. SYNTAX
  811.      RECover [n|*]
  812.  
  813. DESCRIPTION
  814.      The RECOVER command restores the last n changed or deleted lines
  815.      back into the body of the file.
  816.  
  817. COMPATIBILITY
  818.      Compatible.
  819.  
  820. STATUS
  821.      Just started.
  822. **man-end**********************************************************************/
  823. #ifdef PROTO
  824. int Recover(unsigned char *params)
  825. #else
  826. int Recover(params)
  827. unsigned char *params;
  828. #endif
  829. /***********************************************************************/
  830. {
  831. /*--------------------------- local data ------------------------------*/
  832. #define REC_PARAMS  1
  833.  unsigned char *word[REC_PARAMS+1];
  834.  char parm[REC_PARAMS];
  835.  unsigned short num_params;
  836.  int num;
  837. /*--------------------------- processing ------------------------------*/
  838. #ifdef TRACE
  839.  trace_function("comm4.c:   Recover");
  840. #endif
  841. /*---------------------------------------------------------------------*/
  842. /* Validate the parameters that have been supplied. The one and only   */
  843. /* parameter should be a positive integer greater than zero or '*'.    */
  844. /* If no parameter is supplied, 1 is assumed.                          */
  845. /*---------------------------------------------------------------------*/
  846.  num_params = param_split(params,word,REC_PARAMS);
  847.  if (num_params == 0)
  848.     {
  849.      num_params = 1;
  850.      word[0] = (unsigned char *)"1";
  851.     }
  852.  if (num_params != 1)
  853.     {
  854.      display_error(1,word[1]);
  855. #ifdef TRACE
  856.      trace_return();
  857. #endif
  858.      return(OK);
  859.     }
  860.  if (strcmp(word[0],"*") == 0)
  861.    {
  862.     num = 99;
  863.    }
  864.  else
  865.    {
  866.     if (!valid_positive_integer(word[0]))
  867.        {
  868.         display_error(4,word[0]);
  869. #ifdef TRACE
  870.         trace_return();
  871. #endif
  872.         return(OK);
  873.        }
  874.     num = atol(word[0]);
  875.    }
  876.  
  877.  get_from_recovery_list(num);
  878.  
  879. #ifdef TRACE
  880.  trace_return();
  881. #endif
  882.  return(OK);
  883. }
  884. /*man-start*********************************************************************
  885. COMMAND
  886.      refresh - redraw the current screen
  887.  
  888. SYNTAX
  889.      REFresh
  890.  
  891. DESCRIPTION
  892.      The REFRESH command redraws the current contents of the screen.
  893.      This is usually used when some outside influence has stuffed the
  894.      display up.
  895.  
  896. COMPATIBILITY
  897.      Not applicable.
  898.  
  899. STATUS
  900.      Complete.
  901. **man-end**********************************************************************/
  902. #ifdef PROTO
  903. int Refresh(unsigned char *params)
  904. #else
  905. int Refresh(params)
  906. unsigned char *params;
  907. #endif
  908. /***********************************************************************/
  909. {
  910. /*--------------------------- local data ------------------------------*/
  911. /*--------------------------- processing ------------------------------*/
  912. #ifdef TRACE
  913.  trace_function("comm4.c:   Refresh");
  914. #endif
  915.  if (strcmp(params,"") != 0)
  916.    {
  917.     display_error(1,params);
  918. #ifdef TRACE
  919.     trace_return();
  920. #endif
  921.     return(OK);
  922.    }
  923.  wrefresh(curscr);
  924. #ifdef TRACE
  925.  trace_return();
  926. #endif
  927.  return(OK);
  928. }
  929. /*man-start*********************************************************************
  930. COMMAND
  931.      reset - cancel the marked block or prefix commands or both
  932.  
  933. SYNTAX
  934.      RESet ALL|Block|Prefix
  935.  
  936. DESCRIPTION
  937.      The RESET command unmarks any marked block or outstanding prefix
  938.      commands or both.
  939.  
  940. COMPATIBILITY
  941.      Only supports BLOCK... at the moment.
  942.  
  943. STATUS
  944.      Complete.
  945. **man-end**********************************************************************/
  946. #ifdef PROTO
  947. int Reset(unsigned char *params)
  948. #else
  949. int Reset(params)
  950. unsigned char *params;
  951. #endif
  952. /***********************************************************************/
  953. {
  954. /*--------------------------- local data ------------------------------*/
  955. #define RES_PARAMS  1
  956.  unsigned char *word[RES_PARAMS+1];
  957.  unsigned short num_params;
  958. /*--------------------------- processing ------------------------------*/
  959. #ifdef TRACE
  960.  trace_function("comm4.c:   Reset");
  961. #endif
  962.  num_params = param_split(params,word,RES_PARAMS);
  963.  if (num_params > 1)
  964.    {
  965.     display_error(1,word[1]);
  966. #ifdef TRACE
  967.     trace_return();
  968. #endif
  969.     return(OK);
  970.    }
  971.  
  972.  if (equal("block",word[0],5)
  973.  ||  equal("all",word[0],3)
  974.  ||  num_params == 0)
  975.    {
  976.     if (MARK_VIEW != (VIEW_DETAILS *)NULL)
  977.       {
  978.        MARK_VIEW->mark_start_line = MARK_VIEW->mark_end_line = (-1L);
  979.        MARK_VIEW = (VIEW_DETAILS *)NULL;
  980.        show_page();
  981.       }
  982.    }
  983. #ifdef TRACE
  984.  trace_return();
  985. #endif
  986.  return(OK);
  987. }
  988. /*man-start*********************************************************************
  989. COMMAND
  990.      retrieve - return the next/prior command
  991.  
  992. SYNTAX
  993.      ? [+]
  994.  
  995. DESCRIPTION
  996.      The ? command returns the next or prior command from the command
  997.      line stack and displays it on the command line.
  998.      With no parameters, the most recent command entered on the command
  999.      line is retrieved.
  1000.  
  1001. COMPATIBILITY
  1002.      Does not support multiple '?' as in ??? to retrieve the third last
  1003.      command.
  1004.      This command is bound to the up and down arrows when on the
  1005.      command line.
  1006.  
  1007. SEE ALSO
  1008.      cmdarrows
  1009. STATUS
  1010.      Incomplete. Arrows key binding is functional.
  1011. **man-end**********************************************************************/
  1012. #ifdef PROTO
  1013. int Retrieve(unsigned char *params)
  1014. #else
  1015. int Retrieve(params)
  1016. unsigned char *params;
  1017. #endif
  1018. /***********************************************************************/
  1019. {
  1020. /*--------------------------- local data ------------------------------*/
  1021.  char which_way;
  1022.  unsigned char *current_command;
  1023. /*--------------------------- processing ------------------------------*/
  1024. #ifdef TRACE
  1025.  trace_function("comm4.c:   Retrieve");
  1026. #endif
  1027.  if (strcmp(params,"") == 0)
  1028.     which_way = DIRECTION_FORWARD;
  1029.  else
  1030.     if (strcmp(params,"+") == 0)
  1031.       which_way = DIRECTION_BACKWARD;
  1032.     else
  1033.       {
  1034.        display_error(1,params);
  1035. #ifdef TRACE
  1036.        trace_return();
  1037. #endif
  1038.        return(OK);
  1039.       }
  1040.  
  1041.  wmove(CURRENT_WINDOW_COMMAND,0,0);
  1042.  wclrtoeol(CURRENT_WINDOW_COMMAND);
  1043.  current_command = get_command(which_way);
  1044.  if (current_command != (unsigned char *)NULL)
  1045.    {
  1046.     waddstr(CURRENT_WINDOW_COMMAND,current_command);
  1047.     strcpy(cmd_rec,current_command);
  1048.     cmd_rec_len = strlen(cmd_rec);
  1049.    }
  1050. #ifdef TRACE
  1051.  trace_return();
  1052. #endif
  1053.  return(OK);
  1054. }
  1055. /*man-start*********************************************************************
  1056. COMMAND
  1057.      right_arrow - move the cursor to the right
  1058.  
  1059. SYNTAX
  1060.      ** effective only if bound to a key **
  1061.  
  1062. DESCRIPTION
  1063.      The right_arrow key causes the cursor to move one column to the
  1064.      right. If the cursor is on the right most column of the main
  1065.      window, the window will scroll half a window.
  1066.  
  1067. COMPATIBILITY
  1068.      Does not line wrap when encountering the right edge of the screen.
  1069.  
  1070. STATUS
  1071.      Complete
  1072. **man-end**********************************************************************/
  1073. #ifdef PROTO
  1074. int Right_arrow(unsigned char *params)
  1075. #else
  1076. int Right_arrow(params)
  1077. unsigned char *params;
  1078. #endif
  1079. /***********************************************************************/
  1080. {
  1081. /*--------------------------- local data ------------------------------*/
  1082.  unsigned short x,y;
  1083. /*--------------------------- processing ------------------------------*/
  1084. #ifdef TRACE
  1085.  trace_function("comm4.c:   Right_arrow");
  1086. #endif
  1087.  getyx(CURRENT_WINDOW,y,x);
  1088. /*---------------------------------------------------------------------*/
  1089. /* Check for going past end of line - MAX_LINE_LENGTH                  */
  1090. /*---------------------------------------------------------------------*/
  1091.  if (CURRENT_VIEW->verify_col+x+1 > MAX_LINE_LENGTH)
  1092.    {
  1093. #ifdef TRACE
  1094.     trace_return();
  1095. #endif
  1096.     return(OK);
  1097.    }
  1098. /*---------------------------------------------------------------------*/
  1099. /* For all windows, if we are not at right column, move 1 pos to right.*/
  1100. /*---------------------------------------------------------------------*/
  1101.  if (x < CURRENT_SCREEN.cols-1)
  1102.    {
  1103.     wmove(CURRENT_WINDOW,y,x+1);
  1104. #ifdef TRACE
  1105.     trace_return();
  1106. #endif
  1107.     return(OK);
  1108.    }
  1109. /*---------------------------------------------------------------------*/
  1110. /* For MAIN window, if we are at right column, shift to right half the */
  1111. /* width of the main window.                                           */
  1112. /* Check for going past end of line - MAX_LINE_LENGTH                  */
  1113. /*---------------------------------------------------------------------*/
  1114.  if (CURRENT_VIEW->current_window == WINDOW_MAIN)
  1115.     if (x == CURRENT_SCREEN.cols-1)
  1116.       {
  1117.        x = CURRENT_SCREEN.cols / 2;
  1118.        CURRENT_VIEW->verify_col += x;
  1119.        show_page();
  1120.        wmove(CURRENT_WINDOW,y,x);
  1121.       }
  1122. #ifdef TRACE
  1123.  trace_return();
  1124. #endif
  1125.  return(OK);
  1126. }
  1127. /*man-start*********************************************************************
  1128. COMMAND
  1129.      save - save changes to current file
  1130.  
  1131. SYNTAX
  1132.      SAVE [fileid]
  1133.  
  1134. DESCRIPTION
  1135.      The save command writes the current file to disk. If a fileid is
  1136.      supplied, the current file is saved in that file, unless the file
  1137.      already exists when an error is displayed.
  1138.      The 'Alterations' counter on the heading line is reset to zero.
  1139.  
  1140. COMPATIBILITY
  1141.      Complete
  1142.  
  1143. SEE ALSO
  1144.      ssave, file, ffile
  1145.  
  1146. STATUS
  1147.      Complete
  1148. **man-end**********************************************************************/
  1149. #ifdef PROTO
  1150. int Save(unsigned char *params)
  1151. #else
  1152. int Save(params)
  1153. unsigned char *params;
  1154. #endif
  1155. /***********************************************************************/
  1156. {
  1157. /*--------------------------- local data ------------------------------*/
  1158.  short rc;
  1159. /*--------------------------- processing ------------------------------*/
  1160. #ifdef TRACE
  1161.  trace_function("comm4.c:   Save");
  1162. #endif
  1163.  post_process_line(CURRENT_VIEW->focus_line);
  1164.  CURRENT_FILE->autosave_alt = CURRENT_FILE->save_alt = 0;
  1165.  rc =save_file(params,NO,0L,NO);
  1166. #ifdef TRACE
  1167.  trace_return();
  1168. #endif
  1169.  return(rc);
  1170. }
  1171. /*man-start*********************************************************************
  1172. COMMAND
  1173.      schange - selectively change strings
  1174.  
  1175. SYNTAX
  1176.      Change /string1/string2/ [target] [n] [m]
  1177.  
  1178. DESCRIPTION
  1179.      The CHANGE command changes one string of text to another.
  1180.  
  1181.      The first parameter to the change command is the old and new
  1182.      string values, seperated by delimiters.
  1183.      The allowable delimiters are '/' '\' and '@'.
  1184.  
  1185.      The second parameter is the target; how many lines are to be
  1186.      searched for occurrences of the first string to be changed.
  1187.  
  1188.      The third parameter determines how many occurrences of 'string1'
  1189.      are to be changed on each line.
  1190.  
  1191.      The fourth parameter determines at which occurrences of 'string1'
  1192.      on the line are changes to commence.
  1193.  
  1194. COMPATIBILITY
  1195.      Compatible.
  1196.  
  1197. DEFAULT
  1198.      1 1 1
  1199.  
  1200. SEE ALSO
  1201.      change
  1202.  
  1203. STATUS
  1204.      Complete.
  1205. **man-end**********************************************************************/
  1206. #ifdef PROTO
  1207. int Schange(unsigned char *params)
  1208. #else
  1209. int Schange(params)
  1210. unsigned char *params;
  1211. #endif
  1212. /***********************************************************************/
  1213. {
  1214. /*--------------------------- local data ------------------------------*/
  1215.  short rc;
  1216. /*--------------------------- processing ------------------------------*/
  1217. #ifdef TRACE
  1218.  trace_function("comm4.c:   Schange");
  1219. #endif
  1220.  
  1221.  rc = execute_change_command(params,TRUE);
  1222.  
  1223. #ifdef TRACE
  1224.  trace_return();
  1225. #endif
  1226.  return(rc);
  1227. }
  1228. /*man-start*********************************************************************
  1229. COMMAND
  1230.      screen - specifiy number of screens displayed
  1231.  
  1232. SYNTAX
  1233.      SCReen n [Horizontal|Vertical]
  1234.  
  1235. DESCRIPTION
  1236.      The SCREEN command specifies the number of views of file(s) to
  1237.      display on screen at once. If the number of views specified is 2
  1238.      and only one file is currently in the ring, two views of the
  1239.      same file are displayed.
  1240.      Only 2 views are supported.
  1241.  
  1242. COMPATIBILITY
  1243.      Only supports above option.
  1244.  
  1245. STATUS
  1246.      Not complete. (Unavailable)
  1247. **man-end**********************************************************************/
  1248. #ifdef PROTO
  1249. int Screen(unsigned char *params)
  1250. #else
  1251. int Screen(params)
  1252. unsigned char *params;
  1253. #endif
  1254. /***********************************************************************/
  1255. {
  1256. /*--------------------------- local data ------------------------------*/
  1257. #define SCR_PARAMS  2
  1258.  unsigned char *word[SCR_PARAMS+1];
  1259.  register int i;
  1260.  unsigned short num_params,num_views;
  1261.  char save_display_screens;
  1262.  bool save_horizontal;
  1263.  unsigned short x,y;
  1264.  char horiz=(-1);
  1265.  VIEW_DETAILS *save_current_view;
  1266.  
  1267. #ifndef VMS
  1268.  SCREEN_DETAILS *screen0=&screen[0];
  1269.  SCREEN_DETAILS *screen1=&screen[1];
  1270. #endif
  1271. /*--------------------------- processing ------------------------------*/
  1272. #ifdef TRACE
  1273.  trace_function("comm4.c:   Screen");
  1274. #endif
  1275.  
  1276.  num_params = param_split(params,word,SCR_PARAMS);
  1277.  if (!valid_positive_integer(word[0]))
  1278.    {
  1279.     display_error(1,word[0]);
  1280. #ifdef TRACE
  1281.     trace_return();
  1282. #endif
  1283.     return(OK);
  1284.    }
  1285.  if ((num_views = atoi(word[0])) > MAX_SCREENS)
  1286.    {
  1287.     display_error(6,word[0]);
  1288. #ifdef TRACE
  1289.     trace_return();
  1290. #endif
  1291.     return(OK);
  1292.    }
  1293.  if (num_views == 1)
  1294.     horiz = TRUE;
  1295.  else
  1296.    {
  1297.     if (equal("horizontal",word[1],1))
  1298.        horiz = TRUE;
  1299.     if (equal("vertical",word[1],1))
  1300.        horiz = FALSE;
  1301.     if (horiz == (-1))
  1302.       {
  1303.        display_error(1,word[1]);
  1304. #ifdef TRACE
  1305.        trace_return();
  1306. #endif
  1307.        return(OK);
  1308.       }
  1309.    }
  1310. /*---------------------------------------------------------------------*/
  1311. /* Set the global variable display_screens to indicate the number of   */
  1312. /* screens currently displayed and the orientation of those screens    */
  1313. /* Save the old values first so we know how the screens were oriented. */
  1314. /*---------------------------------------------------------------------*/
  1315.  save_display_screens = display_screens;
  1316.  save_horizontal = horizontal;
  1317.  
  1318.  display_screens = (char)num_views;
  1319.  horizontal=(bool)horiz;
  1320.  
  1321.  if (in_profile)
  1322.    {
  1323. #ifdef TRACE
  1324.     trace_return();
  1325. #endif
  1326.     return(OK);
  1327.    }
  1328. /*---------------------------------------------------------------------*/
  1329. /* If there is no change to the screens, exit.                         */
  1330. /*---------------------------------------------------------------------*/
  1331.  if (display_screens == save_display_screens
  1332.  &&  horizontal == save_horizontal)
  1333.    {
  1334. #ifdef TRACE
  1335.     trace_return();
  1336. #endif
  1337.     return(OK);
  1338.    }
  1339. /*---------------------------------------------------------------------*/
  1340. /* CURRENTLY ONLY FOR MAKING 2 VIEWS. NOT FOR GOING BACK TO 1 VIEW.....*/
  1341. /*---------------------------------------------------------------------*/
  1342.  post_process_line(CURRENT_VIEW->focus_line);
  1343.  
  1344.  save_current_view = CURRENT_VIEW;
  1345.  
  1346.  set_screen_defaults();
  1347.  
  1348.  if (!horizontal && display_screens > 1)
  1349.     wnoutrefresh(divider);
  1350.  
  1351.  if (display_screens == 1)
  1352.    {
  1353.     if (CURRENT_SCREEN.screen_view->file_for_view == OTHER_SCREEN.screen_view->file_for_view)
  1354.       {
  1355.        CURRENT_VIEW = OTHER_SCREEN.screen_view;
  1356.        free_view_memory();
  1357.        CURRENT_VIEW = save_current_view;
  1358.       }
  1359.     else
  1360.       {
  1361.        CURRENT_VIEW = OTHER_SCREEN.screen_view;
  1362.        for (i=0;i<VIEW_WINDOWS;i++)
  1363.            getyx(CURRENT_VIEW->win[i],save_coord_y[i],save_coord_x[i]);
  1364.        getyx(CURRENT_WINDOW,y,x);
  1365.        delete_windows();
  1366.        set_up_windows();
  1367.        for (i=0;i<VIEW_WINDOWS;i++)
  1368.            wmove(CURRENT_VIEW->win[i],save_coord_y[i],save_coord_x[i]);
  1369.        y = get_row_for_focus_line(CURRENT_VIEW->current_row,
  1370.                             CURRENT_VIEW->focus_line,
  1371.                             CURRENT_VIEW->current_line);
  1372.        if (x > CURRENT_SCREEN.cols)
  1373.           x = 0;
  1374.        wmove(CURRENT_WINDOW,y,x);
  1375.        CURRENT_VIEW = save_current_view;
  1376.       }
  1377.     current_screen = 0;
  1378.     CURRENT_SCREEN.screen_view = CURRENT_VIEW;
  1379.    }
  1380.  
  1381.  getyx(CURRENT_WINDOW,y,x);
  1382.  delete_windows();
  1383.  set_up_windows();
  1384.  repaint_screen();
  1385.  
  1386.  if (display_screens == 1)
  1387.    {
  1388. #ifdef TRACE
  1389.     trace_return();
  1390. #endif
  1391.     return(OK);
  1392.    }
  1393. /* now create the new view, if this is the only file */
  1394.  
  1395.  if (number_of_views == 1)
  1396.    {
  1397.     if (defaults_for_other_files() == ERROR)
  1398.       {
  1399. #ifdef TRACE
  1400.        trace_return();
  1401. #endif
  1402.        return(ERROR);
  1403.       }
  1404.     CURRENT_FILE = save_current_view->file_for_view;
  1405.     CURRENT_FILE->file_views++;
  1406.     x = y = 0;
  1407.    }
  1408.  else
  1409.    {
  1410.     if (NEXT_VIEW == (VIEW_DETAILS *)NULL)
  1411.        CURRENT_VIEW = vd_first;
  1412.     else
  1413.        CURRENT_VIEW = NEXT_VIEW;
  1414.     getyx(CURRENT_WINDOW,y,x);
  1415.     delete_windows();
  1416.    }
  1417.  current_screen = 1;
  1418.  set_up_windows();
  1419.  CURRENT_SCREEN.screen_view = CURRENT_VIEW;
  1420.  repaint_screen();
  1421.  if (!horizontal)
  1422.    {
  1423.     CURRENT_VIEW = save_current_view;
  1424.     current_screen = 0;
  1425.     pre_process_line(CURRENT_VIEW->focus_line);
  1426.    }
  1427.  
  1428. #ifdef TRACE
  1429.  trace_return();
  1430. #endif
  1431.  return(OK);
  1432. }
  1433. /*man-start*********************************************************************
  1434. COMMAND
  1435.      set - execute various set commands
  1436.  
  1437. SYNTAX
  1438.      SET set command [set command parameter ...]
  1439.  
  1440. DESCRIPTION
  1441.      The SET command is a front end to existing 'set' commands. It treats
  1442.      the first parameter it receives as a command and executes it.
  1443.  
  1444. COMPATIBILITY
  1445.      Compatible.
  1446.  
  1447. STATUS
  1448.      Complete.
  1449. **man-end**********************************************************************/
  1450. #ifdef PROTO
  1451. int Set(unsigned char *params)
  1452. #else
  1453. int Set(params)
  1454. unsigned char *params;
  1455. #endif
  1456. /***********************************************************************/
  1457. {
  1458. /*--------------------------- local data ------------------------------*/
  1459. #define SET_PARAMS  2
  1460.  unsigned char *word[SET_PARAMS+1];
  1461.  unsigned short num_params;
  1462.  unsigned char set_cmd[80];
  1463.  short rc;
  1464. /*--------------------------- processing ------------------------------*/
  1465. #ifdef TRACE
  1466.  trace_function("comm4.c:   Set");
  1467. #endif
  1468.  strcpy(set_cmd,params);
  1469.  num_params = param_split(params,word,SET_PARAMS);
  1470.  if (num_params < 1)
  1471.    {
  1472.     display_error(1,"?????");
  1473. #ifdef TRACE
  1474.     trace_return();
  1475. #endif
  1476.     return(OK);
  1477.    }
  1478.  if (!valid_set_command(word[0]))
  1479.     {
  1480.      display_error(6,word[0]);
  1481. #ifdef TRACE
  1482.     trace_return();
  1483. #endif
  1484.      return(OK);
  1485.     }
  1486.  rc = command_line(set_cmd);
  1487. #ifdef TRACE
  1488.  trace_return();
  1489. #endif
  1490.  return(rc);
  1491. }
  1492. /*man-start*********************************************************************
  1493. COMMAND
  1494.      showkey - display current key value and command assignation
  1495.  
  1496. SYNTAX
  1497.      SHOWKey KEY
  1498.  
  1499. DESCRIPTION
  1500.      The SHOWKEY command prompts the user to enter a key and responds
  1501.      with the key name and associated command (if applicable).
  1502.  
  1503. COMPATIBILITY
  1504.      New feature.
  1505.  
  1506. STATUS
  1507.      Complete.
  1508. **man-end**********************************************************************/
  1509. #ifdef PROTO
  1510. int ShowKey(unsigned char *params)
  1511. #else
  1512. int ShowKey(params)
  1513. unsigned char *params;
  1514. #endif
  1515. /***********************************************************************/
  1516. {
  1517. /*--------------------------- local data ------------------------------*/
  1518.  unsigned short key;
  1519. /*--------------------------- processing ------------------------------*/
  1520. #ifdef TRACE
  1521.  trace_function("comm4.c:   ShowKey");
  1522. #endif
  1523.  display_error(0,"Press the key to be translated...spacebar to exit");
  1524.  touchwin(error_window);
  1525.  doupdate();
  1526.  key = 0;
  1527.  while(key != ' ')
  1528.    {
  1529.     key = my_getch(CURRENT_WINDOW);
  1530.     display_error(0,get_key_definition(key));
  1531.     wrefresh(error_window);
  1532.    }
  1533.  error_on_screen = NO;
  1534.  touchwin(foot);
  1535.  
  1536. #ifdef TRACE
  1537.  trace_return();
  1538. #endif
  1539.  return(OK);
  1540. }
  1541. /*man-start*********************************************************************
  1542. COMMAND
  1543.      spltjoin - split/join two lines
  1544.  
  1545. SYNTAX
  1546.      ** effective only if bound to a key **
  1547.  
  1548. DESCRIPTION
  1549.      The SPLTJOIN command splits the focus line into two or joins the
  1550.      focus line with the next line depending on the position of the
  1551.      cursor. If the cursor is after the last column of a line, a 'join'
  1552.      is executed, otherwise a 'split' is executed.
  1553.  
  1554. COMPATIBILITY
  1555.      Compatible.
  1556.  
  1557. STATUS
  1558.      Incomplete. Does not have [aligned] option.
  1559. **man-end**********************************************************************/
  1560. #ifdef PROTO
  1561. int Spltjoin(unsigned char *params)
  1562. #else
  1563. int Spltjoin(params)
  1564. unsigned char *params;
  1565. #endif
  1566. /***********************************************************************/
  1567. {
  1568. /*--------------------------- local data ------------------------------*/
  1569.  unsigned short x,y,col;
  1570.  LINE *curr;
  1571. /*--------------------------- processing ------------------------------*/
  1572. #ifdef TRACE
  1573.  trace_function("comm4.c:   Spltjoin");
  1574. #endif
  1575. /*---------------------------------------------------------------------*/
  1576. /* Check here for parameter value of 'Aligned' and process accordingly.*/
  1577. /* As you can see, this has not been implemented yet.                  */
  1578. /*---------------------------------------------------------------------*/
  1579.  if (CURRENT_VIEW->current_window != WINDOW_MAIN)
  1580.    {
  1581.     display_error(38,"");
  1582. #ifdef TRACE
  1583.     trace_return();
  1584. #endif
  1585.     return(OK);
  1586.    }
  1587. /*---------------------------------------------------------------------*/
  1588. /* Reject the command if on the top or bottom line.                    */
  1589. /*---------------------------------------------------------------------*/
  1590.  if (CURRENT_VIEW->focus_line == 0
  1591.  ||  CURRENT_VIEW->focus_line == CURRENT_FILE->number_lines+1)
  1592.    {
  1593.     display_error(38,"");
  1594. #ifdef TRACE
  1595.     trace_return();
  1596. #endif
  1597.     return(OK);
  1598.    }
  1599. /*---------------------------------------------------------------------*/
  1600. /* Copy any changes in the focus line to the linked list.              */
  1601. /*---------------------------------------------------------------------*/
  1602.  post_process_line(CURRENT_VIEW->focus_line);
  1603. /*---------------------------------------------------------------------*/
  1604. /* Find the current LINE pointer for the focus_line.                   */
  1605. /*---------------------------------------------------------------------*/
  1606.  curr = ll_find(CURRENT_FILE->first_line,CURRENT_VIEW->focus_line);
  1607.  
  1608.  getyx(CURRENT_WINDOW,y,x);
  1609.  col = (x+CURRENT_VIEW->verify_col-1);
  1610.  if (col >= rec_len)
  1611. /*---------------------------------------------------------------------*/
  1612. /* After the last column of the line, perform a join.                  */
  1613. /*---------------------------------------------------------------------*/
  1614.    {
  1615.     if (curr->next->next == NULL)
  1616.       {
  1617. /*---------------------------------------------------------------------*/
  1618. /* Trying to join with the bottom of file line.                        */
  1619. /*---------------------------------------------------------------------*/
  1620. #ifdef TRACE
  1621.        trace_return();
  1622. #endif
  1623.        return(OK);
  1624.       }
  1625.    meminsmem(rec,curr->next->line,curr->next->length,
  1626.              col,MAX_LINE_LENGTH,col);
  1627.    rec_len = min(MAX_LINE_LENGTH,col+curr->next->length);
  1628.    post_process_line(CURRENT_VIEW->focus_line);
  1629.    curr = ll_del(CURRENT_FILE->first_line,curr->next,DIRECTION_BACKWARD);
  1630. /*---------------------------------------------------------------------*/
  1631. /* Special problem for sos_delline. As the current_line is left where  */
  1632. /* it is, when deleting a line using sos_delline and the current_line  */
  1633. /* is on the bottom-of-file the current_line MUST be reduced by the    */
  1634. /* number of lines deleted. This test can be done here as it is not    */
  1635. /* possible to have this situation when the Delete command is issued   */
  1636. /* from the command window.                                            */
  1637. /*---------------------------------------------------------------------*/
  1638.    if (CURRENT_VIEW->current_line == CURRENT_FILE->number_lines+1)
  1639.      {
  1640.       CURRENT_VIEW->current_line--;
  1641.       y++;
  1642.      }
  1643. /*---------------------------------------------------------------------*/
  1644. /* Decrement the number of lines counter for the current file and move */
  1645. /* the cursor to the appropriate line.                                 */
  1646. /*---------------------------------------------------------------------*/
  1647.    CURRENT_FILE->number_lines--;
  1648.    wmove(CURRENT_WINDOW,y,x);
  1649.    }
  1650.  else
  1651. /*---------------------------------------------------------------------*/
  1652. /* Before the last column of the line, perform a split.                */
  1653. /*---------------------------------------------------------------------*/
  1654.    {
  1655.     add_line(CURRENT_FILE->first_line,curr,(curr->line+col),
  1656.                rec_len - col);
  1657.     CURRENT_FILE->number_lines++;
  1658.     Sos_delend("");
  1659.     post_process_line(CURRENT_VIEW->focus_line);
  1660.    }
  1661.  show_page();
  1662. #ifdef TRACE
  1663.  trace_return();
  1664. #endif
  1665.  return(OK);
  1666. }
  1667. /*man-start*********************************************************************
  1668. COMMAND
  1669.      ssave - save changes to current file
  1670.  
  1671. SYNTAX
  1672.      SSave [fileid]
  1673.  
  1674. DESCRIPTION
  1675.      The ssave command writes the current file to disk. If a fileid is
  1676.      supplied, the current file is saved in that file, otherwise the
  1677.      current name of the file is used.
  1678.      If a fileid is supplied and that fileid already exists, the previous
  1679.      contents of that fileid will be replaced with the current file.
  1680.      The 'Alterations' counter on the heading line is reset to zero.
  1681.  
  1682. COMPATIBILITY
  1683.      Complete
  1684.  
  1685. SEE ALSO
  1686.      save, file, ffile
  1687.  
  1688. STATUS
  1689.      Complete
  1690. **man-end**********************************************************************/
  1691. #ifdef PROTO
  1692. int Ssave(unsigned char *params)
  1693. #else
  1694. int Ssave(params)
  1695. unsigned char *params;
  1696. #endif
  1697. /***********************************************************************/
  1698. {
  1699. /*--------------------------- local data ------------------------------*/
  1700.  short rc;
  1701. /*--------------------------- processing ------------------------------*/
  1702. #ifdef TRACE
  1703.  trace_function("comm4.c:   Ssave");
  1704. #endif
  1705.  post_process_line(CURRENT_VIEW->focus_line);
  1706.  CURRENT_FILE->autosave_alt = CURRENT_FILE->save_alt = 0;
  1707.  rc = save_file(params,YES,0L,NO);
  1708. #ifdef TRACE
  1709.  trace_return();
  1710. #endif
  1711.  return(rc);
  1712. }
  1713. /*man-start*********************************************************************
  1714. COMMAND
  1715.      stay - set condition of cursor position after CHANGE/LOCATE commands
  1716.  
  1717. SYNTAX
  1718.      STAY ON|OFF
  1719.  
  1720. DESCRIPTION
  1721.      The STAY set command determines what line is displayed as the current
  1722.      line after an unsuccessful LOCATE command or after a CHANGE command.
  1723.      With STAY ON, the current line remains where it currently is. With
  1724.      STAY OFF, after an unsuccessful LOCATE, the current line is "Bottom
  1725.      of File". After a successful CHANGE, the current line is the last
  1726.      line affected by the CHANGE command.
  1727.  
  1728. COMPATIBILITY
  1729.      Complete
  1730.  
  1731. DEFAULT
  1732.      STAY ON
  1733.  
  1734. STATUS
  1735.      Complete
  1736. **man-end**********************************************************************/
  1737. #ifdef PROTO
  1738. int Stay(unsigned char *params)
  1739. #else
  1740. int Stay(params)
  1741. unsigned char *params;
  1742. #endif
  1743. /***********************************************************************/
  1744. {
  1745. /*--------------------------- extern data -----------------------------*/
  1746. extern unsigned char STAYx;
  1747. /*--------------------------- local data ------------------------------*/
  1748. #define STA_PARAMS  1
  1749.  char parm[STA_PARAMS];
  1750.  unsigned char *word[STA_PARAMS+1];
  1751.  register int i;
  1752.  unsigned short num_params;
  1753. /*--------------------------- processing ------------------------------*/
  1754. #ifdef TRACE
  1755.  trace_function("comm4.c:   Stay");
  1756. #endif
  1757.  num_params = param_split(params,word,STA_PARAMS);
  1758.  
  1759.  parm[0] = UNDEFINED_OPERAND;
  1760.  if (equal("on",word[0],2))
  1761.     parm[0] = ON;
  1762.  if (equal("off",word[0],3))
  1763.     parm[0] = OFF;
  1764.  if (parm[0] == UNDEFINED_OPERAND)
  1765.    {
  1766.     display_error(1,word[0]);
  1767. #ifdef TRACE
  1768.     trace_return();
  1769. #endif
  1770.     return(OK);
  1771.    }
  1772.  if (in_profile)
  1773.     STAYx = parm[0];
  1774.  else
  1775.     CURRENT_VIEW->stay = parm[0];
  1776. #ifdef TRACE
  1777.  trace_return();
  1778. #endif
  1779.  return(OK);
  1780. }
  1781.